Software Development
Modeling Entities Using Classes and Objects
Modeling Entities in Java: Defining Custom Classes & Objects
it_jpmecodj_02_enus
Modeling Entities in Java: Getting Started with Classes & Objects
it_jpmecodj_01_enus
Modeling Entities in Java: Methods, Method Overloading, & Constructors
it_jpmecodj_03_enus
Modeling Entities in Java: Static Members, Arguments, & Method Overriding
it_jpmecodj_04_enus
Modeling Entities in Java: Defining Custom Classes & Objects
Lesson Objectives
Modeling Entities in Java: Defining Custom Classes & Objects
- discover the key concepts covered in this course
- instantiate objects of built-in Java classes
- create objects in Java and access object information
- perform operations on Java objects
- create member variables in Java and view their values
- create constructors and use them to instantiate objects in Java
- define constructors and use them to initialize member variables in Java
- create, access, and view private member variables in Java
- define and invoke private methods in Java
- explore type safety in getter methods and edit member fields with setter methods in Java
- summarize the key concepts covered in this course
Overview/Description
Modeling entities in the real world require you to create custom classes to add to the various built-in classes already provided by Java. Creating such custom classes is key to harnessing the power of object-oriented programming (OOP) in Java. This course focuses on defining such custom classes and then creating objects. Make the most of this course by exploring custom classes, the use of constructors, and modifiers such as private and public. You will also learn the idiomatic Java method of working with getter and setter methods as well as conventions in naming, input parameters, and return types from such methods. After completing this course, you'll not only be able to define custom classes to serve as types in your programs but also instantiate and use objects of these custom classes.
Modeling entities in the real world require you to create custom classes to add to the various built-in classes already provided by Java. Creating such custom classes is key to harnessing the power of object-oriented programming (OOP) in Java. This course focuses on defining such custom classes and then creating objects. Make the most of this course by exploring custom classes, the use of constructors, and modifiers such as private and public. You will also learn the idiomatic Java method of working with getter and setter methods as well as conventions in naming, input parameters, and return types from such methods. After completing this course, you'll not only be able to define custom classes to serve as types in your programs but also instantiate and use objects of these custom classes.
Target
Prerequisites: none
Modeling Entities in Java: Getting Started with Classes & Objects
Lesson Objectives
Modeling Entities in Java: Getting Started with Classes & Objects
- discover the key concepts covered in this course
- recall how a Java class is a template with attributes and actions
- recognize that classes are blueprints and objects are instances of classes
- identify the difference between static and instance variables
- create a new Java class within an IntelliJ project
- set up an IntelliJ run configuration and instantiate class objects
- summarize the key concepts covered in this course
Overview/Description
Classes are a core concept in Java's object-oriented programming model. The class is an abstract type and an object is an instance of that type. Object oriented Java programming allows classes to be instantiated and inherit features from the Java.lang.object. You will learn about member variables, fields, functions, and methods. Learn to instantiate objects of built-in Java classes and invoke methods on them.
Target
Prerequisites: none
Modeling Entities in Java: Methods, Method Overloading, & Constructors
Lesson Objectives
Modeling Entities in Java: Methods, Method Overloading, & Constructors
- discover the key concepts covered in this course
- implement return values and types correctly
- create objects of a Java class and use getters and setters to edit fields
- overload methods with the same name in Java
- recall how overloaded methods work and how they can invoke one another
- use the default, no-argument constructor to create objects
- initialize fields in constructor definitions
- create and use parameterized constructors in Java
- create multiple constructors with different signatures
- initialize fields using the 'this' keyword
- reuse code using constructor chaining
- summarize the key concepts covered in this course
Overview/Description
Modeling complex entities involves defining and invoking methods and constructors. Furthermore, defining robust and reusable code requires learning important mechanisms for code re-uses, such as constructor chaining and method overloading. Use this course to delve into these important techniques that are required to write clean and maintainable Java code. Learn how to define methods with the same name but different signatures (i.e., different order and type of input arguments), invoke overloaded methods, and add constructors to a class. This course will also enable you to use the 'this' keyword to invoke multiple constructors, also known as constructor chaining. By the time you are done with this course, you will have the skills to use important code re-use mechanisms such as method overloading and constructor chaining in java.
Modeling complex entities involves defining and invoking methods and constructors. Furthermore, defining robust and reusable code requires learning important mechanisms for code re-uses, such as constructor chaining and method overloading. Use this course to delve into these important techniques that are required to write clean and maintainable Java code. Learn how to define methods with the same name but different signatures (i.e., different order and type of input arguments), invoke overloaded methods, and add constructors to a class. This course will also enable you to use the 'this' keyword to invoke multiple constructors, also known as constructor chaining. By the time you are done with this course, you will have the skills to use important code re-use mechanisms such as method overloading and constructor chaining in java.
Target
Prerequisites: none
Modeling Entities in Java: Static Members, Arguments, & Method Overriding
Lesson Objectives
Modeling Entities in Java: Static Members, Arguments, & Method Overriding
- discover the key concepts covered in this course
- recall Java best practices to access static variables
- use class references to access static variables and describe the use of the 'final' keyword
- outline access restrictions on instance members from static members
- implement a scenario using a static variable to count instantiated objects
- use class reference to invoke and execute static methods
- reassign variables inside methods and explore where the changes are visible
- contrast the effects of variable reassignment with variable modification
- outline pass-by-value and pass-by-reference with custom objects
- recall the operation of the == operator and the default .equals() method
- examine how to work with the .equals() and .hashCode() methods and the hashCode contract
- override .equals() to check for semantic equality
- override .hashCode() and .equals() to honor the hashCode contract
- summarize the key concepts covered in this course
Overview/Description
The best way to avoid mysterious bugs while running your Java code is to be adept at working with static members, argument passing, and object base class methods?. Use this course to master these subtleties: the difference between static and instance variables and methods, the hashCode contract, and how pass-by-value and pass-by-reference semantics play out with argument passing in Java. By the end of this course, you'll be able to model state in classes using both static and instance variables, write methods to avoid unexpected changes in input arguments, and adhere to the hashCode contract so that objects function as expected when placed in common Java containers.
The best way to avoid mysterious bugs while running your Java code is to be adept at working with static members, argument passing, and object base class methods?. Use this course to master these subtleties: the difference between static and instance variables and methods, the hashCode contract, and how pass-by-value and pass-by-reference semantics play out with argument passing in Java. By the end of this course, you'll be able to model state in classes using both static and instance variables, write methods to avoid unexpected changes in input arguments, and adhere to the hashCode contract so that objects function as expected when placed in common Java containers.
Target
Prerequisites: none
